/**
 * 评论数据查询脚本
 * 
 * 用法：
 *   node query-reviews.js                    # 查询所有评论
 *   node query-reviews.js --asin B0CTMGGJDV  # 查询指定商品的评论
 *   node query-reviews.js --rating 5         # 查询指定评分的评论
 *   node query-reviews.js --verified         # 只查询验证购买的评论
 *   node query-reviews.js --stats            # 显示统计信息
 */

const dbConnection = require('./db/connection');
const Review = require('./db/models/Review');

// 解析命令行参数
function parseArgs() {
    const args = process.argv.slice(2);
    const options = {
        asin: null,
        rating: null,
        verified: false,
        stats: false,
        limit: 10
    };
    
    for (let i = 0; i < args.length; i++) {
        const arg = args[i];
        
        if (arg === '--asin' && i + 1 < args.length) {
            options.asin = args[i + 1];
            i++;
        } else if (arg === '--rating' && i + 1 < args.length) {
            options.rating = parseFloat(args[i + 1]);
            i++;
        } else if (arg === '--verified') {
            options.verified = true;
        } else if (arg === '--stats') {
            options.stats = true;
        } else if (arg === '--limit' && i + 1 < args.length) {
            options.limit = parseInt(args[i + 1]);
            i++;
        } else if (arg === '--help' || arg === '-h') {
            console.log(`
评论数据查询工具

用法：
  node query-reviews.js [选项]

选项：
  --asin <ASIN>      查询指定商品的评论
  --rating <评分>    查询指定评分的评论（1-5）
  --verified         只查询验证购买的评论
  --stats            显示统计信息
  --limit <数量>     限制返回数量（默认：10）
  -h, --help         显示帮助信息

示例：
  node query-reviews.js
  node query-reviews.js --asin B0CTMGGJDV
  node query-reviews.js --rating 5 --verified
  node query-reviews.js --stats
  node query-reviews.js --asin B0CTMGGJDV --limit 20
            `);
            process.exit(0);
        }
    }
    
    return options;
}

// 显示评论列表
function displayReviews(reviews) {
    if (reviews.length === 0) {
        console.log('\n📭 未找到评论\n');
        return;
    }
    
    console.log(`\n📝 找到 ${reviews.length} 条评论:\n`);
    console.log('='.repeat(80));
    
    reviews.forEach((review, index) => {
        console.log(`\n${index + 1}. ${review.title || '(无标题)'}`);
        console.log(`   评论ID: ${review.reviewId}`);
        console.log(`   评论者: ${review.author || '匿名'}`);
        console.log(`   评分: ${'⭐'.repeat(Math.floor(review.rating || 0))} (${review.rating || 'N/A'})`);
        console.log(`   ASIN: ${review.asin || 'N/A'}`);
        console.log(`   商品: ${review.productTitle || 'N/A'}`);
        console.log(`   日期: ${review.date || 'N/A'}`);
        console.log(`   有帮助: ${review.helpfulCount || 0} 人`);
        console.log(`   验证购买: ${review.isVerifiedPurchase ? '✅ 是' : '❌ 否'}`);
        if (review.variantInfo) {
            console.log(`   变体: ${review.variantInfo}`);
        }
        if (review.body) {
            const bodyPreview = review.body.substring(0, 100);
            console.log(`   内容: ${bodyPreview}${review.body.length > 100 ? '...' : ''}`);
        }
        console.log(`   爬取时间: ${review.crawlTimestamp ? new Date(review.crawlTimestamp).toLocaleString('zh-CN') : 'N/A'}`);
    });
    
    console.log('\n' + '='.repeat(80) + '\n');
}

// 显示统计信息
async function displayStats() {
    try {
        console.log('\n📊 评论数据统计\n');
        console.log('='.repeat(80));
        
        // 总评论数
        const totalReviews = await Review.countDocuments();
        console.log(`\n📝 总评论数: ${totalReviews}`);
        
        // 按任务统计
        const taskStats = await Review.aggregate([
            { $group: { _id: '$taskName', count: { $sum: 1 } } },
            { $sort: { count: -1 } }
        ]);
        console.log(`\n📋 按任务统计:`);
        taskStats.forEach(stat => {
            console.log(`   ${stat._id || '(未知)'}: ${stat.count} 条`);
        });
        
        // 按评分统计
        const ratingStats = await Review.aggregate([
            { $group: { _id: '$rating', count: { $sum: 1 } } },
            { $sort: { _id: -1 } }
        ]);
        console.log(`\n⭐ 按评分统计:`);
        ratingStats.forEach(stat => {
            const stars = '★'.repeat(Math.floor(stat._id || 0));
            console.log(`   ${stars} ${stat._id || 'N/A'}: ${stat.count} 条`);
        });
        
        // 验证购买统计
        const verifiedCount = await Review.countDocuments({ isVerifiedPurchase: true });
        const unverifiedCount = totalReviews - verifiedCount;
        console.log(`\n✅ 验证购买:`);
        console.log(`   是: ${verifiedCount} 条`);
        console.log(`   否: ${unverifiedCount} 条`);
        
        // 平均评分
        const avgRatingResult = await Review.aggregate([
            { $group: { _id: null, avgRating: { $avg: '$rating' } } }
        ]);
        if (avgRatingResult.length > 0) {
            console.log(`\n📊 平均评分: ${avgRatingResult[0].avgRating.toFixed(2)}`);
        }
        
        // 最有帮助的评论
        const topHelpful = await Review.find()
            .sort({ helpfulCount: -1 })
            .limit(3);
        
        if (topHelpful.length > 0) {
            console.log(`\n🏆 最有帮助的评论（Top 3）:`);
            topHelpful.forEach((review, index) => {
                console.log(`   ${index + 1}. "${review.title}" - ${review.helpfulCount} 人认为有帮助`);
            });
        }
        
        // 最新评论
        const latestReviews = await Review.find()
            .sort({ crawlTimestamp: -1 })
            .limit(3);
        
        if (latestReviews.length > 0) {
            console.log(`\n🕐 最新爬取的评论（Top 3）:`);
            latestReviews.forEach((review, index) => {
                const time = new Date(review.crawlTimestamp).toLocaleString('zh-CN');
                console.log(`   ${index + 1}. "${review.title}" - ${time}`);
            });
        }
        
        console.log('\n' + '='.repeat(80) + '\n');
        
    } catch (error) {
        console.error('❌ 统计失败:', error.message);
    }
}

// 主函数
async function main() {
    console.log('========================================');
    console.log('    评论数据查询工具');
    console.log('========================================\n');
    
    const options = parseArgs();
    
    try {
        // 连接数据库
        await dbConnection.connect();
        
        if (options.stats) {
            // 显示统计信息
            await displayStats();
        } else {
            // 构建查询条件
            const query = {};
            
            if (options.asin) {
                query.asin = options.asin;
                console.log(`🔍 查询商品: ${options.asin}`);
            }
            
            if (options.rating) {
                query.rating = options.rating;
                console.log(`⭐ 筛选评分: ${options.rating}`);
            }
            
            if (options.verified) {
                query.isVerifiedPurchase = true;
                console.log(`✅ 只显示验证购买`);
            }
            
            // 查询评论
            const reviews = await Review.find(query)
                .sort({ crawlTimestamp: -1 })
                .limit(options.limit);
            
            // 显示结果
            displayReviews(reviews);
            
            // 显示总数
            const totalCount = await Review.countDocuments(query);
            if (totalCount > options.limit) {
                console.log(`💡 提示: 共有 ${totalCount} 条符合条件的评论，当前显示前 ${options.limit} 条`);
                console.log(`   使用 --limit 参数查看更多，例如: --limit 50\n`);
            }
        }
        
    } catch (error) {
        console.error('❌ 查询失败:', error.message);
        console.error('   详情:', error.stack);
    } finally {
        // 关闭数据库连接
        await dbConnection.disconnect();
    }
}

// 运行
if (require.main === module) {
    main().catch(console.error);
}

module.exports = main;

